Crate deno_core[−][src]

Re-exports

`pub use futures;`
`pub use rusty_v8 as v8;`
`pub use serde;`
`pub use serde_json;`
`pub use url;`

Helps embed JS files in an extension. Returns Vec<(&’static str, Box)> representing the filename and source code. This is only meant for extensions that will be snapshotted, as code will be loaded at runtime.

Structs

AsyncRefCell
CancelHandle
Canceled
Extension
FsModuleLoader	Basic file system module loader.
InspectorSessionProxy	Encapsulates an UnboundedSender/UnboundedReceiver pair that together form a duplex channel for sending/receiving messages in V8 session.
JsRuntime	A single execution context of JavaScript. Corresponds roughly to the “Web Worker” concept in the DOM. A JsRuntime is a Future that can be used with an event loop (Tokio, async_std). The JsRuntime future completes when there is an error or when all pending ops have completed.
JsRuntimeInspector	This structure is used responsible for providing inspector interface to the `JsRuntime`.
LocalInspectorSession	A local inspector session that can be used to send and receive protocol messages directly on the same thread as an isolate.
ModuleSource	EsModule source code that will be loaded into V8.
NoopModuleLoader	Placeholder structure used when creating a runtime that doesn’t support module loading.
OpPayload
OpState	Maintains the resources and ops inside a JS runtime.
OpTable	Collection for storing registered ops. The special ‘get_op_catalog’ op with OpId `0` is automatically added when the OpTable is created.
RcRef	An `RcRef` encapsulates a reference counted pointer, just like a regular `std::rc::Rc`. However, unlike a regular `Rc`, it can be remapped so that it dereferences to any value that’s reachable through the reference-counted pointer. This is achieved through the associated method, `RcRef::map()`, similar to how `std::cell::Ref::map()` works. Example:
RecursiveModuleLoad	This future is used to implement parallel async module loading.
ResourceTable	Map-like data structure storing Deno’s resources (equivalent to file descriptors).
RuntimeOptions
TryCancelable

Enums

Cancelable
ModuleResolutionError	Error indicating the reason resolving a module specifier failed.
Op
OpResult
Snapshot
ZeroCopyBuf

Constants

DUMMY_SPECIFIER

Traits

CancelFuture
CancelTryFuture
ModuleLoader
RcLike	The `RcLike` trait provides an abstraction over `std::rc::Rc` and `RcRef`, so that applicable methods can operate on either type.
Resource	All objects that can be store in the resource table should implement the `Resource` trait.

Functions

normalize_path	Normalize all intermediate components of the path (ie. remove “./” and “../” components). Similar to `fs::canonicalize()` but doesn’t resolve symlinks.
op_async	Creates an op that passes data asynchronously using JSON.
op_close	Remove a resource from the resource table.
op_print	Builtin utility to print to stdout/stderr
op_resources	Return map of resources with id as key and string representation as value.
op_sync	Creates an op that passes data synchronously using JSON.
resolve_import	Resolves module using this algorithm: https://html.spec.whatwg.org/multipage/webappapis.html#resolve-a-module-specifier
resolve_path	Converts a string representing a relative or absolute path into a ModuleSpecifier. A relative path is considered relative to the current working directory.
resolve_url	Converts a string representing an absolute URL into a ModuleSpecifier.
resolve_url_or_path	Takes a string representing either an absolute URL or a file path, as it may be passed to deno as a command line argument. The string is interpreted as a URL if it starts with a valid URI scheme, e.g. ‘http:’ or ‘file:’ or ‘git+ssh:’. If not, it’s interpreted as a file path; if it is a relative path it’s resolved relative to the current working directory.
serialize_op_result
v8_set_flags	Pass the command line arguments to v8. Returns a vector of command line arguments that V8 did not understand.
v8_version

Type Definitions

AsyncMut
AsyncMutFuture
AsyncRef
AsyncRefFuture
GetErrorClassFn
JsErrorCreateFn
ModuleId
ModuleLoadId
ModuleSourceFuture
ModuleSpecifier	Resolved module specifier
OpAsyncFuture
OpFn
OpId
OpMiddlewareFn
PromiseId
ResourceId	A `ResourceId` is an integer value referencing a resource. It could be considered to be the Deno equivalent of a `file descriptor` in POSIX like operating systems. Elsewhere in the code base it is commonly abbreviated to `rid`.